{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Write summaries\n",
    "\n",
    "TensorBoard helps us to summerize important parameters (such as wieghts, biases, activations, accuracy, loss, ...) to see how each parameter changes in each iteration of the training.\n",
    "\n",
    "We can also see the images using TensorBoard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports:\n",
    "We will start with importing the needed libraries for our code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# imports\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Input data:\n",
    "For this tutorial we use the MNIST dataset. MNIST is a dataset of handwritten digits. If you are into machine learning, you might have heard of this dataset by now. MNIST is kind of benchmark of datasets for deep learning. One other reason that we use the MNIST is that it is easily accesible through Tensorflow. If you want to know more about the MNIST dataset you can check Yann Lecun's website.\n",
    "We can easily import the dataset and see the size of training, test and validation set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting MNIST_data/train-images-idx3-ubyte.gz\n",
      "Extracting MNIST_data/train-labels-idx1-ubyte.gz\n",
      "Extracting MNIST_data/t10k-images-idx3-ubyte.gz\n",
      "Extracting MNIST_data/t10k-labels-idx1-ubyte.gz\n",
      "Size of:\n",
      "- Training-set:\t\t55000\n",
      "- Test-set:\t\t10000\n",
      "- Validation-set:\t5000\n"
     ]
    }
   ],
   "source": [
    "# Import MNIST data\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "mnist = input_data.read_data_sets(\"MNIST_data/\", one_hot=True)\n",
    "\n",
    "print(\"Size of:\")\n",
    "print(\"- Training-set:\\t\\t{}\".format(len(mnist.train.labels)))\n",
    "print(\"- Test-set:\\t\\t{}\".format(len(mnist.test.labels)))\n",
    "print(\"- Validation-set:\\t{}\".format(len(mnist.validation.labels)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hyper-parameters:\n",
    "Hyper-parameters are important parameters which are not learned by the network. So, we have to specify them externally. These parameters are constant and they are not learnable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# hyper-parameters\n",
    "logs_path = \"./logs/write_summaries\"  # path to the folder that we want to save the logs for TensorBoard\n",
    "learning_rate = 0.001  # The optimization learning rate\n",
    "epochs = 10  # Total number of training epochs\n",
    "batch_size = 100  # Training batch size\n",
    "display_freq = 100  # Frequency of displaying the training results\n",
    "\n",
    "# Network Parameters\n",
    "# We know that MNIST images are 28 pixels in each dimension.\n",
    "img_h = img_w = 28\n",
    "\n",
    "# Images are stored in one-dimensional arrays of this length.\n",
    "img_size_flat = img_h * img_w\n",
    "\n",
    "# Number of classes, one class for each of 10 digits.\n",
    "n_classes = 10\n",
    "\n",
    "# number of units in the first hidden layer\n",
    "h1 = 200"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Graph:\n",
    "Like before, we start by constructing the graph. But, we need to define some functions that we need rapidly in our code.\n",
    "\n",
    "To visualize the parameters, we will use ```tf.summary``` class to write the summaries of parameters.\n",
    "\n",
    "Notice ```tf.summary.histogram()```__ functions added to the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# weight and bais wrappers\n",
    "def weight_variable(name, shape):\n",
    "    \"\"\"\n",
    "    Create a weight variable with appropriate initialization\n",
    "    :param name: weight name\n",
    "    :param shape: weight shape\n",
    "    :return: initialized weight variable\n",
    "    \"\"\"\n",
    "    initer = tf.truncated_normal_initializer(stddev=0.01)\n",
    "    return tf.get_variable('W_' + name,\n",
    "                           dtype=tf.float32,\n",
    "                           shape=shape,\n",
    "                           initializer=initer)\n",
    "\n",
    "\n",
    "def bias_variable(name, shape):\n",
    "    \"\"\"\n",
    "    Create a bias variable with appropriate initialization\n",
    "    :param name: bias variable name\n",
    "    :param shape: bias variable shape\n",
    "    :return: initialized bias variable\n",
    "    \"\"\"\n",
    "    initial = tf.constant(0., shape=shape, dtype=tf.float32)\n",
    "    return tf.get_variable('b_' + name,\n",
    "                           dtype=tf.float32,\n",
    "                           initializer=initial)\n",
    "\n",
    "\n",
    "def fc_layer(x, num_units, name, use_relu=True):\n",
    "    \"\"\"\n",
    "    Create a fully-connected layer\n",
    "    :param x: input from previous layer\n",
    "    :param num_units: number of hidden units in the fully-connected layer\n",
    "    :param name: layer name\n",
    "    :param use_relu: boolean to add ReLU non-linearity (or not)\n",
    "    :return: The output array\n",
    "    \"\"\"\n",
    "    with tf.variable_scope(name):\n",
    "        in_dim = x.get_shape()[1]\n",
    "        W = weight_variable(name, shape=[in_dim, num_units])\n",
    "        tf.summary.histogram('W', W)\n",
    "        b = bias_variable(name, [num_units])\n",
    "        tf.summary.histogram('b', b)\n",
    "        layer = tf.matmul(x, W)\n",
    "        layer += b\n",
    "        if use_relu:\n",
    "            layer = tf.nn.relu(layer)\n",
    "        return layer\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have our helper functions we can create our graph.\n",
    "\n",
    "To visualize some scalar values (such as loss and accuracy) we will use __```tf.summary.scalar()```__.\n",
    "\n",
    "To visualize some images we will use __```tf.summary.image()```__.\n",
    "\n",
    "Finally, to merge all the summeries, we will use __```tf.summary.merge_all()```__ function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Create graph\n",
    "# Placeholders for inputs (x), outputs(y)\n",
    "with tf.variable_scope('Input'):\n",
    "    x = tf.placeholder(tf.float32, shape=[None, img_size_flat], name='X')\n",
    "    tf.summary.image('input_image', tf.reshape(x, (-1, img_w, img_h, 1)), max_outputs=5)\n",
    "    y = tf.placeholder(tf.float32, shape=[None, n_classes], name='Y')\n",
    "fc1 = fc_layer(x, h1, 'Hidden_layer', use_relu=True)\n",
    "output_logits = fc_layer(fc1, n_classes, 'Output_layer', use_relu=False)\n",
    "\n",
    "# Define the loss function, optimizer, and accuracy\n",
    "with tf.variable_scope('Train'):\n",
    "    with tf.variable_scope('Loss'):\n",
    "        loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=output_logits), name='loss')\n",
    "        tf.summary.scalar('loss', loss)\n",
    "    with tf.variable_scope('Optimizer'):\n",
    "        optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate, name='Adam-op').minimize(loss)\n",
    "    with tf.variable_scope('Accuracy'):\n",
    "        correct_prediction = tf.equal(tf.argmax(output_logits, 1), tf.argmax(y, 1), name='correct_pred')\n",
    "        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32), name='accuracy')\n",
    "        tf.summary.scalar('accuracy', accuracy)\n",
    "        # Network predictions\n",
    "        cls_prediction = tf.argmax(output_logits, axis=1, name='predictions')\n",
    "\n",
    "\n",
    "# Initializing the variables\n",
    "init = tf.global_variables_initializer()\n",
    "merged = tf.summary.merge_all()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train:\n",
    "As soon as the graph is created, we can run it on a session.\n",
    "\n",
    "A ```tf.Session()``` is as good as it's runtime. As soon as the cell is run, the session will be ended and we will loose all the information. So. we will define an _InteractiveSession_ to keep the parameters for testing.\n",
    "\n",
    "\n",
    "__NOTE:__ Each time that we run our session, we have to pass the _```merged```_ variable (which we merged all the summerize in) and we have to add the summaries in our __```tf.summary.FileWriter```__ class using __```add_summary```__ method in our class.\n",
    "\n",
    "__NOTE:__ We can let the summary writer class know that these summaries are for which step by passing the _```step```_ which we are in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training epoch: 1\n",
      "iter   0:\t Loss=2.28,\tTraining Accuracy=49.0%\n",
      "iter 100:\t Loss=0.48,\tTraining Accuracy=85.0%\n",
      "iter 200:\t Loss=0.28,\tTraining Accuracy=94.0%\n",
      "iter 300:\t Loss=0.31,\tTraining Accuracy=95.0%\n",
      "iter 400:\t Loss=0.28,\tTraining Accuracy=94.0%\n",
      "iter 500:\t Loss=0.28,\tTraining Accuracy=91.0%\n",
      "---------------------------------------------------------\n",
      "Epoch: 1, validation loss: 0.21, validation accuracy: 94.0%\n",
      "---------------------------------------------------------\n",
      "Training epoch: 2\n",
      "iter   0:\t Loss=0.14,\tTraining Accuracy=95.0%\n",
      "iter 100:\t Loss=0.24,\tTraining Accuracy=93.0%\n",
      "iter 200:\t Loss=0.20,\tTraining Accuracy=94.0%\n",
      "iter 300:\t Loss=0.19,\tTraining Accuracy=93.0%\n",
      "iter 400:\t Loss=0.20,\tTraining Accuracy=93.0%\n",
      "iter 500:\t Loss=0.05,\tTraining Accuracy=99.0%\n",
      "---------------------------------------------------------\n",
      "Epoch: 2, validation loss: 0.14, validation accuracy: 96.2%\n",
      "---------------------------------------------------------\n",
      "Training epoch: 3\n",
      "iter   0:\t Loss=0.17,\tTraining Accuracy=96.0%\n",
      "iter 100:\t Loss=0.15,\tTraining Accuracy=94.0%\n",
      "iter 200:\t Loss=0.19,\tTraining Accuracy=93.0%\n",
      "iter 300:\t Loss=0.10,\tTraining Accuracy=97.0%\n",
      "iter 400:\t Loss=0.27,\tTraining Accuracy=94.0%\n",
      "iter 500:\t Loss=0.15,\tTraining Accuracy=96.0%\n",
      "---------------------------------------------------------\n",
      "Epoch: 3, validation loss: 0.12, validation accuracy: 96.7%\n",
      "---------------------------------------------------------\n",
      "Training epoch: 4\n",
      "iter   0:\t Loss=0.08,\tTraining Accuracy=99.0%\n",
      "iter 100:\t Loss=0.11,\tTraining Accuracy=98.0%\n",
      "iter 200:\t Loss=0.09,\tTraining Accuracy=96.0%\n",
      "iter 300:\t Loss=0.06,\tTraining Accuracy=98.0%\n",
      "iter 400:\t Loss=0.05,\tTraining Accuracy=100.0%\n",
      "iter 500:\t Loss=0.06,\tTraining Accuracy=98.0%\n",
      "---------------------------------------------------------\n",
      "Epoch: 4, validation loss: 0.11, validation accuracy: 97.0%\n",
      "---------------------------------------------------------\n",
      "Training epoch: 5\n",
      "iter   0:\t Loss=0.09,\tTraining Accuracy=99.0%\n",
      "iter 100:\t Loss=0.04,\tTraining Accuracy=99.0%\n",
      "iter 200:\t Loss=0.07,\tTraining Accuracy=98.0%\n",
      "iter 300:\t Loss=0.08,\tTraining Accuracy=98.0%\n",
      "iter 400:\t Loss=0.03,\tTraining Accuracy=100.0%\n",
      "iter 500:\t Loss=0.08,\tTraining Accuracy=98.0%\n",
      "---------------------------------------------------------\n",
      "Epoch: 5, validation loss: 0.09, validation accuracy: 97.3%\n",
      "---------------------------------------------------------\n",
      "Training epoch: 6\n",
      "iter   0:\t Loss=0.07,\tTraining Accuracy=98.0%\n",
      "iter 100:\t Loss=0.08,\tTraining Accuracy=97.0%\n",
      "iter 200:\t Loss=0.03,\tTraining Accuracy=99.0%\n",
      "iter 300:\t Loss=0.05,\tTraining Accuracy=99.0%\n",
      "iter 400:\t Loss=0.02,\tTraining Accuracy=100.0%\n",
      "iter 500:\t Loss=0.07,\tTraining Accuracy=99.0%\n",
      "---------------------------------------------------------\n",
      "Epoch: 6, validation loss: 0.09, validation accuracy: 97.4%\n",
      "---------------------------------------------------------\n",
      "Training epoch: 7\n",
      "iter   0:\t Loss=0.07,\tTraining Accuracy=98.0%\n",
      "iter 100:\t Loss=0.03,\tTraining Accuracy=100.0%\n",
      "iter 200:\t Loss=0.06,\tTraining Accuracy=99.0%\n",
      "iter 300:\t Loss=0.06,\tTraining Accuracy=98.0%\n",
      "iter 400:\t Loss=0.08,\tTraining Accuracy=97.0%\n",
      "iter 500:\t Loss=0.03,\tTraining Accuracy=99.0%\n",
      "---------------------------------------------------------\n",
      "Epoch: 7, validation loss: 0.07, validation accuracy: 97.8%\n",
      "---------------------------------------------------------\n",
      "Training epoch: 8\n",
      "iter   0:\t Loss=0.02,\tTraining Accuracy=100.0%\n",
      "iter 100:\t Loss=0.07,\tTraining Accuracy=99.0%\n",
      "iter 200:\t Loss=0.08,\tTraining Accuracy=98.0%\n",
      "iter 300:\t Loss=0.05,\tTraining Accuracy=99.0%\n",
      "iter 400:\t Loss=0.06,\tTraining Accuracy=98.0%\n",
      "iter 500:\t Loss=0.10,\tTraining Accuracy=97.0%\n",
      "---------------------------------------------------------\n",
      "Epoch: 8, validation loss: 0.07, validation accuracy: 97.9%\n",
      "---------------------------------------------------------\n",
      "Training epoch: 9\n",
      "iter   0:\t Loss=0.02,\tTraining Accuracy=100.0%\n",
      "iter 100:\t Loss=0.04,\tTraining Accuracy=99.0%\n",
      "iter 200:\t Loss=0.07,\tTraining Accuracy=99.0%\n",
      "iter 300:\t Loss=0.03,\tTraining Accuracy=99.0%\n",
      "iter 400:\t Loss=0.10,\tTraining Accuracy=96.0%\n",
      "iter 500:\t Loss=0.03,\tTraining Accuracy=100.0%\n",
      "---------------------------------------------------------\n",
      "Epoch: 9, validation loss: 0.08, validation accuracy: 97.8%\n",
      "---------------------------------------------------------\n",
      "Training epoch: 10\n",
      "iter   0:\t Loss=0.03,\tTraining Accuracy=100.0%\n",
      "iter 100:\t Loss=0.01,\tTraining Accuracy=100.0%\n",
      "iter 200:\t Loss=0.01,\tTraining Accuracy=100.0%\n",
      "iter 300:\t Loss=0.03,\tTraining Accuracy=98.0%\n",
      "iter 400:\t Loss=0.01,\tTraining Accuracy=100.0%\n",
      "iter 500:\t Loss=0.06,\tTraining Accuracy=99.0%\n",
      "---------------------------------------------------------\n",
      "Epoch: 10, validation loss: 0.07, validation accuracy: 98.0%\n",
      "---------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "# Launch the graph (session)\n",
    "sess = tf.InteractiveSession() # using InteractiveSession instead of Session to test network in separate cell\n",
    "sess.run(init)\n",
    "train_writer = tf.summary.FileWriter(logs_path, sess.graph)\n",
    "num_tr_iter = int(mnist.train.num_examples / batch_size)\n",
    "global_step = 0\n",
    "for epoch in range(epochs):\n",
    "    print('Training epoch: {}'.format(epoch + 1))\n",
    "    for iteration in range(num_tr_iter):\n",
    "        batch_x, batch_y = mnist.train.next_batch(batch_size)\n",
    "        global_step += 1\n",
    "        # Run optimization op (backprop)\n",
    "        feed_dict_batch = {x: batch_x, y: batch_y}\n",
    "        _, summary_tr = sess.run([optimizer, merged], feed_dict=feed_dict_batch)\n",
    "        train_writer.add_summary(summary_tr, global_step)\n",
    "\n",
    "        if iteration % display_freq == 0:\n",
    "            # Calculate and display the batch loss and accuracy\n",
    "            loss_batch, acc_batch = sess.run([loss, accuracy],\n",
    "                                             feed_dict=feed_dict_batch)\n",
    "            print(\"iter {0:3d}:\\t Loss={1:.2f},\\tTraining Accuracy={2:.01%}\".\n",
    "                  format(iteration, loss_batch, acc_batch))\n",
    "\n",
    "    # Run validation after every epoch\n",
    "    feed_dict_valid = {x: mnist.validation.images, y: mnist.validation.labels}\n",
    "    loss_valid, acc_valid = sess.run([loss, accuracy], feed_dict=feed_dict_valid)\n",
    "    print('---------------------------------------------------------')\n",
    "    print(\"Epoch: {0}, validation loss: {1:.2f}, validation accuracy: {2:.01%}\".\n",
    "          format(epoch + 1, loss_valid, acc_valid))\n",
    "    print('---------------------------------------------------------')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test:\n",
    "Now that the model is trained. It is time to test our model.\n",
    "\n",
    "We will define some helper functions to plot some of the images and their corresponding predicted and true classes. We will also visualize some of the misclassified samples to see why the Neural Net failed to classify them correctly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def plot_images(images, cls_true, cls_pred=None, title=None):\n",
    "    \"\"\"\n",
    "    Create figure with 3x3 sub-plots.\n",
    "    :param images: array of images to be plotted, (9, img_h*img_w)\n",
    "    :param cls_true: corresponding true labels (9,)\n",
    "    :param cls_pred: corresponding true labels (9,)\n",
    "    \"\"\"\n",
    "    fig, axes = plt.subplots(3, 3, figsize=(9, 9))\n",
    "    fig.subplots_adjust(hspace=0.3, wspace=0.3)\n",
    "    img_h = img_w = np.sqrt(images.shape[-1]).astype(int)\n",
    "    for i, ax in enumerate(axes.flat):\n",
    "        # Plot image.\n",
    "        ax.imshow(images[i].reshape((img_h, img_w)), cmap='binary')\n",
    "\n",
    "        # Show true and predicted classes.\n",
    "        if cls_pred is None:\n",
    "            ax_title = \"True: {0}\".format(cls_true[i])\n",
    "        else:\n",
    "            ax_title = \"True: {0}, Pred: {1}\".format(cls_true[i], cls_pred[i])\n",
    "\n",
    "        ax.set_title(ax_title)\n",
    "\n",
    "        # Remove ticks from the plot.\n",
    "        ax.set_xticks([])\n",
    "        ax.set_yticks([])\n",
    "    \n",
    "    if title:\n",
    "        plt.suptitle(title, size=20)\n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "def plot_example_errors(images, cls_true, cls_pred, title=None):\n",
    "    \"\"\"\n",
    "    Function for plotting examples of images that have been mis-classified\n",
    "    :param images: array of all images, (#imgs, img_h*img_w)\n",
    "    :param cls_true: corresponding true labels, (#imgs,)\n",
    "    :param cls_pred: corresponding predicted labels, (#imgs,)\n",
    "    \"\"\"\n",
    "    # Negate the boolean array.\n",
    "    incorrect = np.logical_not(np.equal(cls_pred, cls_true))\n",
    "\n",
    "    # Get the images from the test-set that have been\n",
    "    # incorrectly classified.\n",
    "    incorrect_images = images[incorrect]\n",
    "\n",
    "    # Get the true and predicted classes for those images.\n",
    "    cls_pred = cls_pred[incorrect]\n",
    "    cls_true = cls_true[incorrect]\n",
    "\n",
    "    # Plot the first 9 images.\n",
    "    plot_images(images=incorrect_images[0:9],\n",
    "                cls_true=cls_true[0:9],\n",
    "                cls_pred=cls_pred[0:9],\n",
    "                title=title)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------------------------------------------------------\n",
      "Test loss: 0.08, test accuracy: 97.5%\n",
      "---------------------------------------------------------\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1d50d1d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1d50dc18>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test the network after training\n",
    "# Accuracy\n",
    "feed_dict_test = {x: mnist.test.images, y: mnist.test.labels}\n",
    "loss_test, acc_test = sess.run([loss, accuracy], feed_dict=feed_dict_test)\n",
    "print('---------------------------------------------------------')\n",
    "print(\"Test loss: {0:.2f}, test accuracy: {1:.01%}\".format(loss_test, acc_test))\n",
    "print('---------------------------------------------------------')\n",
    "\n",
    "# Plot some of the correct and misclassified examples\n",
    "cls_pred = sess.run(cls_prediction, feed_dict=feed_dict_test)\n",
    "cls_true = np.argmax(mnist.test.labels, axis=1)\n",
    "plot_images(mnist.test.images, cls_true, cls_pred, title='Correct Examples')\n",
    "plot_example_errors(mnist.test.images, cls_true, cls_pred, title='Misclassified Examples')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After we are finished the testing, we will close the session to free the memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# close the session after you are done with testing\n",
    "sess.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At this step our coding is done. We have also plotted the accuarcy and some examples. But to inspect more in our network, we can run the __Tensorboard__. Open your terminal and type:\n",
    "```bash\n",
    "tensorboard --logdir=logs/write_summaries --host localhost\n",
    "```\n",
    "and Open the generated link in your browser.\n",
    "\n",
    "__NOTE:__ Don't forget to activate your environment !!!\n",
    "\n",
    "You can see the images, scalars and histograms in added tabs:\n",
    "\n",
    "__Image summaries:__\n",
    "<img src=\"https://github.com/easy-tensorflow/easy-tensorflow/raw/master/4_Tensorboard/Tutorials/files/image_summaries.png\">\n",
    "\n",
    "__Scalar summaries:__\n",
    "<img src=\"https://github.com/easy-tensorflow/easy-tensorflow/raw/master/4_Tensorboard/Tutorials/files/scalar_summaries.png\">\n",
    "\n",
    "__Histogram summaries:__\n",
    "<img src=\"https://github.com/easy-tensorflow/easy-tensorflow/raw/master/4_Tensorboard/Tutorials/files/hist_summaries.png\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thanks for reading! If you have any question or doubt, feel free to leave a comment in our [website](http://easy-tensorflow.com/)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
